{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用NER&Denpendency Prasing对句子进行解析 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 句子依存关系解析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "分析步骤：\n",
    "1. 把文章切断成句子\n",
    "2. 对条句子进行分析"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sqlalchemy import Column, String, create_engine\n",
    "from sqlalchemy.orm import sessionmaker\n",
    "from sqlalchemy.ext.declarative import declarative_base\n",
    "from sqlalchemy.sql import select"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "passward = '###'\n",
    "host = '###'\n",
    "user = 'root'\n",
    "post = '3306'\n",
    "database = 'stu_db'\n",
    "engine= create_engine(\"mysql+mysqlconnector://{}:{}@{}:{}/{}\".format(user,passward,host,post,database))\n",
    "connection = engine.connect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "id_list = connection.execute(\"select id from news_chinese\")\n",
    "id_list = id_list.fetchall()\n",
    "content_list = connection.execute(\"select content from news_chinese\")\n",
    "content_list = content_list.fetchall()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "命名实体识别标注集:\n",
    "- 标记 =\t含义\n",
    "- O =\t这个词不是NE\n",
    "- S =\t这个词单独构成一个NE\n",
    "- B =\t这个词为一个NE的开始\n",
    "- I =\t这个词为一个NE的中间\n",
    "- E =\t这个词位一个NE的结尾\n",
    "- Nh =\t人名\n",
    "- Ni =\t机构名\n",
    "- Ns =\t地名"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用依存句法分析找出观点的内容，以下代码是测试时候方便调试的代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code_folding": [
     8,
     15,
     21,
     27,
     35,
     42,
     46,
     51,
     64
    ]
   },
   "outputs": [],
   "source": [
    "from pyltp import Segmentor\n",
    "from pyltp import Postagger\n",
    "from pyltp import NamedEntityRecognizer\n",
    "from pyltp import SentenceSplitter\n",
    "from pyltp import Parser\n",
    "import os\n",
    "\n",
    "#分句\n",
    "def cut_sentence(string):\n",
    "    \"\"\"@string contain many sentence\"\"\"\n",
    "    from pyltp import SentenceSplitter\n",
    "    sents = SentenceSplitter.split(string)  # 分句\n",
    "    return list(sents)\n",
    "    \n",
    "#分词\n",
    "def cut_word(sentence,model):\n",
    "    \"\"\"@sentence is a string\"\"\"\n",
    "    words = model.segment(sentence)  # 分词\n",
    "    return list(words)\n",
    "\n",
    "#词信标注\n",
    "def pos_label(words, mdoel):\n",
    "    \"\"\"@words is a list result of cut word\"\"\"\n",
    "    postags = mdoel.postag(words)  # 词性标注\n",
    "    return list(postags)\n",
    "\n",
    "#命名实体识别\n",
    "def ner_label(words, postags, model):\n",
    "    \"\"\"@words is a list  result of cut word\n",
    "       @postags is a list result of Part-Of-Speech tagging\n",
    "    \"\"\"\n",
    "    netags = model.recognize(words, postags)  # 命名实体识别\n",
    "    return list(netags)\n",
    "\n",
    "#依存句法分析\n",
    "def dependency_parsing(words, postags, model):\n",
    "    \"\"\"@words is a list  result of cut word\n",
    "       @postags is a list result of Part-Of-Speech tagging\n",
    "    \"\"\" \n",
    "    arcs = model.parse(words, postags)  # 句法分析\n",
    "    return list(arcs)\n",
    "\n",
    "def find_word_index(word,words):\n",
    "    for i in range(len(words)):\n",
    "        if words[i] == word:\n",
    "            return i\n",
    "def find_head(den_parsing_list):\n",
    "    for i in range(len(den_parsing_list)):\n",
    "        if den_parsing_list[i].head == 0:\n",
    "            return i\n",
    "\n",
    "def search_index(start, den_parsing_list,word_list):\n",
    "    tree_dict = {word_list[start]:{}}\n",
    "    j=0\n",
    "    for i,arc in enumerate(den_parsing_list):\n",
    "        if arc.head == start+1:\n",
    "            j +=1\n",
    "            tree_dict[word_list[start]][word_list[i]] = \\\n",
    "            search_index(i,den_parsing_list,word_list)\n",
    "    if j==0:return word_list[start]\n",
    "    return tree_dict  \n",
    "\n",
    "from collections import defaultdict\n",
    "#该函数找出树形结构关系，并返回关系，层数和最大宽度，方便图绘制\n",
    "def search_find_dict(start, den_parsing_list,word_list_orgin):\n",
    "    word_list = []\n",
    "    #对重复词进行重新编号，以区别\n",
    "    for i,word in enumerate(word_list_orgin):\n",
    "        if word in word_list:\n",
    "            word_list.append(word+'_'+str(i))\n",
    "        else:\n",
    "            word_list.append(word)\n",
    "            \n",
    "    tree_dict = defaultdict(list)\n",
    "    \n",
    "    current_layer = 0\n",
    "    length = len(start)\n",
    "    max_length = 0\n",
    "    while start!= []:\n",
    "        current_p = start.pop(0)\n",
    "        length -= 1 \n",
    "        for i,arc in enumerate(den_parsing_list):\n",
    "            if arc.head == current_p+1:\n",
    "                start.append(i)\n",
    "                tree_dict[word_list[current_p]] += [[word_list[i],arc.relation]]\n",
    "        #当遍历到下一层时\n",
    "        if length == 0:\n",
    "            current_layer +=1\n",
    "            length = len(start)\n",
    "            if max_length < length:\n",
    "                max_length = length\n",
    "    return tree_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def pretty_print(word_list, ner_list):   \n",
    "    import math\n",
    "    num = math.ceil(len(word_list)/14)\n",
    "    index = range(1, len(word_list)+1)\n",
    "    for line_num in range(num):\n",
    "        str1 = ''\n",
    "        str2 = ''\n",
    "        str3 = ''\n",
    "        if line_num == num -1:\n",
    "            word_temp = word_list[line_num*14:]\n",
    "            ner_temp = ner_list[line_num*14:]\n",
    "            index_temp = index[line_num*14:]\n",
    "        else:\n",
    "            word_temp = word_list[line_num*14:(line_num+1)*14]\n",
    "            ner_temp = ner_list[line_num*14:(line_num+1)*14]   \n",
    "            index_temp = index[line_num*14:(line_num+1)*14]\n",
    "        for i, j in zip(word_temp, ner_temp):\n",
    "            i_len = len(i)\n",
    "            j_len = len(j)\n",
    "            if i_len > 5:\n",
    "                str1 += '{}\\t|'\n",
    "                str2 += '{}\\t\\t|'\n",
    "                str3 += '{}\\t\\t|'\n",
    "            else:\n",
    "                str1 += '{}\\t|'\n",
    "                str2 += '{}\\t|'\n",
    "                str3 += '{}\\t|'\n",
    "        print(str3.format(*index_temp))\n",
    "        print(str1.format(*word_temp))\n",
    "        print(str2.format(*ner_temp),'\\n')\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams['font.sans-serif']= ['SimHei']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "自定义个绘制了依存句法关系的模块：\n",
    "\n",
    "模块在plottree.plottree 里的 createPlot方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "去掉标点，对比一下结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 针对说等次词，找出其宾语即说的内容"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "#输入显示调整函数\n",
    "def pretty_print(word_list, ner_list):   \n",
    "    import math\n",
    "    num = math.ceil(len(word_list)/14)\n",
    "    index = range(1, len(word_list)+1)\n",
    "    for line_num in range(num):\n",
    "        str1 = ''\n",
    "        str2 = ''\n",
    "        str3 = ''\n",
    "        if line_num == num -1:\n",
    "            word_temp = word_list[line_num*14:]\n",
    "            ner_temp = ner_list[line_num*14:]\n",
    "            index_temp = index[line_num*14:]\n",
    "        else:\n",
    "            word_temp = word_list[line_num*14:(line_num+1)*14]\n",
    "            ner_temp = ner_list[line_num*14:(line_num+1)*14]   \n",
    "            index_temp = index[line_num*14:(line_num+1)*14]\n",
    "        for i, j in zip(word_temp, ner_temp):\n",
    "            i_len = len(i)\n",
    "            j_len = len(j)\n",
    "            if i_len > 5:\n",
    "                str1 += '{}\\t|'\n",
    "                str2 += '{}\\t\\t|'\n",
    "                str3 += '{}\\t\\t|'\n",
    "            else:\n",
    "                str1 += '{}\\t|'\n",
    "                str2 += '{}\\t|'\n",
    "                str3 += '{}\\t|'\n",
    "        print(str3.format(*index_temp))\n",
    "        print(str1.format(*word_temp))\n",
    "        print(str2.format(*ner_temp),'\\n')\n",
    "        \n",
    "def table_print(word_list, ner_list):\n",
    "    import prettytable as pt\n",
    "    tb = pt.PrettyTable()\n",
    "    tb.add_column('1',word_list)\n",
    "    tb.add_column('2',ner_list)\n",
    "    print(tb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import gc\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {
    "code_folding": [
     14,
     40,
     49,
     56,
     67,
     74,
     80,
     107,
     185
    ]
   },
   "outputs": [],
   "source": [
    "##完成项目代码\n",
    "from collections import defaultdict\n",
    "from pyltp import Segmentor\n",
    "from pyltp import Postagger\n",
    "from pyltp import NamedEntityRecognizer\n",
    "from pyltp import SentenceSplitter\n",
    "from pyltp import Parser\n",
    "from gensim.models import KeyedVectors\n",
    "import numpy as np\n",
    "import jieba\n",
    "import os\n",
    "import time\n",
    "from collections import Counter\n",
    "\n",
    "def get_sentences_vec(model_wv, sent_list, word_frequence):\n",
    "    # 句子向量化处理\n",
    "    a = 0.001\n",
    "    row = model_wv.vector_size\n",
    "    col = len(sent_list)\n",
    "    sent_mat = np.zeros((row, col))\n",
    "    for i, sent in enumerate(sent_list):\n",
    "        length = len(sent)\n",
    "        sent_vec = np.zeros(row)\n",
    "        for word in sent:\n",
    "            pw = word_frequence[word]\n",
    "            w = a / (a + pw)\n",
    "            try:\n",
    "                vec = np.array(model_wv[word])\n",
    "                sent_vec += w * vec\n",
    "            except:\n",
    "                pass\n",
    "        sent_mat[:, i] += sent_vec\n",
    "        sent_mat[:, i] /= length\n",
    "\n",
    "    # PCA处理\n",
    "    sent_mat = np.mat(sent_mat)\n",
    "    u, s, vh = np.linalg.svd(sent_mat)\n",
    "    sent_mat = sent_mat - u * u.T * sent_mat\n",
    "    return sent_mat\n",
    "\n",
    "def get_word_frequence(words):\n",
    "    #这里不做停用次处理，直接在计算句子向量时候，如果找不到该词，直接跳过\n",
    "    word_list = []\n",
    "    for word in words:\n",
    "        word_list += word\n",
    "    word_frequence = Counter(word_list)\n",
    "    return word_frequence\n",
    "\n",
    "# 计算余弦相似度\n",
    "def cos_similarity(v1, v2):\n",
    "    #输入向量维度不一致\n",
    "    if len(v1) != len(v2):\n",
    "        return 0\n",
    "    return np.vdot(v1,v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))\n",
    "\n",
    "# 返回句子向量矩阵中各列向量与第一列向量的相似度\n",
    "def calcu_similarity(sent_mat):\n",
    "    #采用点积的方法计算\n",
    "    first = np.array(sent_mat[:, 0]).flatten()\n",
    "    col = sent_mat.shape[1]\n",
    "    sims = []\n",
    "    for i in range(1, col):\n",
    "        vec = np.array(sent_mat[:, i]).flatten()\n",
    "        sims.append(cos_similarity(first, vec))\n",
    "    return sims\n",
    "\n",
    "#获取相似度结果\n",
    "def get_similarity_result(word_list_all, model_wv):\n",
    "    word_frequence = get_word_frequence(word_list_all)\n",
    "    sent_mat = get_sentences_vec(model_wv, word_list_all,word_frequence)\n",
    "    sim = calcu_similarity(sent_mat)\n",
    "    return sim\n",
    "\n",
    "#分句\n",
    "def cut_sentence(string):\n",
    "    \"\"\"@string contain many sentence\"\"\"\n",
    "    from pyltp import SentenceSplitter\n",
    "    sents = SentenceSplitter.split(string)  # 分句\n",
    "    return list(sents)\n",
    "\n",
    "def load_all_model():\n",
    "    \"\"\"返回分词，词性标注，命名实体识别，依存解析等实例对象\"\"\"\n",
    "    LTP_DATA_DIR = 'E:/MYGIT/Project/ltp_data'  # ltp模型目录的路径\n",
    "    cws_model_path = os.path.join(LTP_DATA_DIR, 'cws.model')  # 分词模型路径，模型名称为`cws.model`\n",
    "    segmentor = Segmentor()  # 初始化实例\n",
    "    segmentor.load_with_lexicon(cws_model_path, '../ltp_data/cut_external_dict/cut_external_dict')  # 加载模型\n",
    "    \n",
    "    LTP_DATA_DIR = 'E:/MYGIT/Project/ltp_data'  # ltp模型目录的路径\n",
    "    pos_model_path = os.path.join(LTP_DATA_DIR, 'pos.model')  # 词性标注模型路径，模型名称为`pos.model`\n",
    "    postagger = Postagger() # 初始化实例\n",
    "    postagger.load_with_lexicon(pos_model_path, '../ltp_data/pos_external_dict/pos_external_dict')  # 加载模型\n",
    "\n",
    "    LTP_DATA_DIR = 'E:/MYGIT/Project/ltp_data'  # ltp模型目录的路径\n",
    "    ner_model_path = os.path.join(LTP_DATA_DIR, 'ner.model')  # 命名实体识别模型路径，模型名称为`pos.model`\n",
    "    recognizer = NamedEntityRecognizer() # 初始化实例\n",
    "    recognizer.load(ner_model_path)  # 加载模型\n",
    "\n",
    "    LTP_DATA_DIR = 'E:/MYGIT/Project/ltp_data'  # ltp模型目录的路径\n",
    "    par_model_path = os.path.join(LTP_DATA_DIR, 'parser.model')  # 依存句法分析模型路径，模型名称为`parser.model`   \n",
    "    parser = Parser() # 初始化实例\n",
    "    parser.load(par_model_path)  # 加载模型\n",
    "    \n",
    "    fname = r\"E:/MYGIT/model/wiki_stopwords/wiki_word2vec.kv\"\n",
    "    #model_wv.save(fname)\n",
    "    model_wv = KeyedVectors.load(fname, mmap='r')\n",
    "    return [segmentor, postagger, recognizer, parser,model_wv]\n",
    "\n",
    "def release_all_model(model_list):\n",
    "    del(model_list[-1])\n",
    "    for each in model_list:\n",
    "        each.release()\n",
    "\n",
    "#获取人名或机构名\n",
    "def get_name(word_list, prase, ner_list, pos_list,say_index):\n",
    "    # 合并说话对象名字\n",
    "    index = -1\n",
    "    for arc in prase:\n",
    "        if arc.relation == \"SBV\" and arc.head == say_index + 1:\n",
    "            index = prase.index(arc)\n",
    "            #break\n",
    "            # 第二种情况\n",
    "    if index == -1:\n",
    "        for arc in prase:\n",
    "            if arc.relation == \"SBV\" and arc.head == prase[say_index].head and prase[say_index].relation == \"COO\":\n",
    "                index = prase.index(arc)\n",
    "    # 两种情况都没找到\n",
    "    if index == -1: return ''\n",
    "\n",
    "    Entity = ('S-Nh', 'S-Ni', 'S-Ns','B-Nh', 'B-Ni','B-Ns', 'I-Nh', 'I-Ni','I-Ns', 'E-Nh', 'E-Ni','E-Ns')  # 命名实体标记\n",
    "    #Entity = ('S-Nh', 'S-Ni')  # 命名实体标记\n",
    "    name = ''\n",
    "    cur = index\n",
    "    ret_flag = False\n",
    "    while cur >= 0:\n",
    "        if ner_list[cur] in Entity or cur == index:\n",
    "            name = word_list[cur] + name   \n",
    "            if ner_list[cur] in Entity:ret_flag = True\n",
    "            cur -= 1\n",
    "        else:\n",
    "            break\n",
    "\n",
    "    if ret_flag:return name\n",
    "    if pos_list[index] not in ('n', 'nh', 'ws'): return ''\n",
    "    \n",
    "    pre = word_list[:index]  # 前半部分\n",
    "    pos = word_list[index + 1:]  # 后半部分\n",
    "    while pre:\n",
    "        w = pre.pop(-1)\n",
    "        w_index = word_list.index(w)\n",
    "        # if prase[w_index].relation == 'ADV': continue\n",
    "        if prase[w_index].relation in ('WP', 'ATT', 'SVB') and (w not in ('，','。','、','）','（')):\n",
    "            name = w + name\n",
    "        else:\n",
    "            pre = False\n",
    "    while pos:\n",
    "        w = pos.pop(0)\n",
    "        w_index = word_list.index(w)\n",
    "        if prase[w_index].head - 1 == index or \\\n",
    "                prase[prase[w_index].head - 1].head - 1 == index or \\\n",
    "                prase[prase[prase[w_index].head - 1].head - 1].head - 1 == index:\n",
    "            if prase[w_index].relation in ('WP', 'LAD', 'COO', 'RAD', 'ATT') and w_index < say_index and (\n",
    "                    w not in ('，', '。', '、', '）', '（')):\n",
    "                name = name + w  # 向后拼接\n",
    "            else:  # 中断拼接直接返回\n",
    "                pos = False\n",
    "        else:\n",
    "            pos = False\n",
    "    return name \n",
    " \n",
    "def get_under_node(parent_node, parse, relation):\n",
    "    index = []\n",
    "    for arc in parse:\n",
    "        if arc.relation == relation and arc.head == parent_node +1:\n",
    "            index.append(parse.index(arc))\n",
    "    try:\n",
    "        return index\n",
    "    except NameError:\n",
    "        return -1 \n",
    "    \n",
    "#找出输入所有节点中最小的索引和最大的索引，然后返回两者间的句子\n",
    "def node_under_sentence(parent_point, den_parsing_list, word_list):    \n",
    "    words_index = []\n",
    "    #搜索子节点\n",
    "    if parent_point == [] or parent_point[0] < 0 :return ''\n",
    "    for point in parent_point:\n",
    "        start = [point]\n",
    "        words_index.append(start[0])\n",
    "        while start!= []:\n",
    "            cur = start.pop(0)\n",
    "            for i, arc in enumerate(den_parsing_list):\n",
    "                if arc.head == cur + 1:\n",
    "                    words_index.append(i)\n",
    "                    start.append(i)\n",
    "    words_index = sorted(words_index)\n",
    "    #print(words_index, len(word_list))\n",
    "    return ''.join(word_list[words_index[0]:words_index[-1]+1])\n",
    "\n",
    "#从文件中提取与说相关的词\n",
    "def get_relatedwords():\n",
    "    path  = 'E:/MYGIT/Project/NLP-Project-1/related_words/saywords'\n",
    "    relatedwords_list = []\n",
    "    with open(path, encoding='utf-8') as f:\n",
    "        line_str= f.readline()\n",
    "        while line_str  != '':\n",
    "            relatedwords_list.append(line_str.strip('\\n'))\n",
    "            line_str = f.readline()\n",
    "    relatedwords_list = tuple(relatedwords_list)\n",
    "    return relatedwords_list\n",
    "\n",
    "def find_opinion_of_someone(input_news, say_related, model_list):\n",
    "    # 输入文本进行分句\n",
    "    segmentor = model_list[0]\n",
    "    postagger = model_list[1]\n",
    "    recognizer= model_list[2]\n",
    "    parser= model_list[3]\n",
    "    model_wv = model_list[4]\n",
    "\n",
    "    sentence_list = cut_sentence(input_news)\n",
    "    sentence_list = [sen for sen in sentence_list if len(sen) > 3]\n",
    "    Entity = ['S-Nh', 'S-Ni','B-Nh', 'B-Ni', 'I-Nh', 'I-Ni', 'E-Nh', 'E-Ni']  # 命名实体标记\n",
    "    pro_news_dict = defaultdict(list) #用来存储可能是多句的句子\n",
    "    news_dict = defaultdict(list)\n",
    "    \n",
    "    word_list_all = [list(segmentor.segment(sentence)) for sentence in sentence_list]  # 分词\n",
    "    #name_list = [] #用于保存所有人名\n",
    "    for _i, sentence in enumerate(sentence_list):\n",
    "        #print('\\n——————————句子:{} 处理过程——————————'.format(_i + 1))\n",
    "        #time_point_1 = time.time()\n",
    "        word_list = word_list_all[_i]  #     \n",
    "        pos_list = list(postagger.postag(word_list))  # 词性分析\n",
    "        ner_list = list(recognizer.recognize(word_list, pos_list))  # 命名实体提取\n",
    "        den_parsing_list = list(parser.parse(word_list, pos_list))  # 依存关系\n",
    "                       \n",
    "        # 获取命名实体和说相关词,同时获取索引值\n",
    "        pro_say_word = [(a, i) for i, a in enumerate(word_list) if a in say_related]  \n",
    "        if pro_say_word==[]:continue\n",
    "        \n",
    "        # 找到说的主语\n",
    "        for say in pro_say_word:\n",
    "            if say[0] in (':','：') and den_parsing_list[say[1]].relation == 'WP':\n",
    "                say = (say[0], den_parsing_list[say[1]].head-1)\n",
    "            name = get_name(word_list, den_parsing_list, ner_list, pos_list, say[1])\n",
    "            #print('第{}句子, sayword:{} name:{}'.format(_i, say, name))\n",
    "            if name != '':\n",
    "                say_underword = []\n",
    "                index = get_under_node(say[1], den_parsing_list, 'VOB')           \n",
    "                if index != -1: \n",
    "                    _flag = len(index)\n",
    "                    say_underword += index\n",
    "                    index = get_under_node(say[1], den_parsing_list, 'COO')\n",
    "                    if index != -1: say_underword += index\n",
    "                        \n",
    "                #特殊情况处理1\n",
    "                if len(say_underword) > _flag:\n",
    "                    for _node in range(_flag):\n",
    "                        if pos_list[say_underword[_node]] in ['n','nh']:\n",
    "                            say_underword.pop(0)\n",
    "                \n",
    "                #特殊情况处理2\n",
    "                saying = node_under_sentence(say_underword, den_parsing_list, word_list)\n",
    "                if not saying:\n",
    "                    if (den_parsing_list[say[1]].relation =='POB' and den_parsing_list[den_parsing_list[say[1]].head-1].relation == 'ADV'):\n",
    "                        saying = ''.join(word_list[say[1]+1:])\n",
    "                        saying = saying.strip('，')\n",
    "                    if not saying:\n",
    "                        if _i>0:\n",
    "                            quotations = re.findall(r'“(.+?)”', sentence_list[_i-1])\n",
    "                            if quotations and len(quotations[-1])> 6: saying = quotations[-1]\n",
    "                if saying != '':\n",
    "                    if saying[-5:] in sentence[-9:]:\n",
    "                        words1 = jieba.lcut(saying)\n",
    "                        _word_list = sentence_list[_i+1:_i+4] #切片的话_i+4如果超出则取到末尾\n",
    "                        _word_list.insert(0, words1)\n",
    "                        sim = get_similarity_result(_word_list, model_wv)\n",
    "                        #print(sim)\n",
    "                        for i_sim, _sim in enumerate(sim):\n",
    "                            if _sim > 0.85:\n",
    "                                pro_news_dict[_i] += [sentence_list[_i + i_sim+1]]\n",
    "                            else:\n",
    "                                break\n",
    "                    news_dict[_i] = [name, say[0], saying]\n",
    "                    break  \n",
    "    \n",
    "    #对多句添加进行判断，如果下一句里没说，或没提取出来，则拼接到上一句，避免重复\n",
    "    for key in pro_news_dict.keys():\n",
    "        for _i in range(len(pro_news_dict[key])):\n",
    "            if key+_i+1 not in news_dict.keys():\n",
    "                news_dict[key][1] += pro_news_dict[key][_i]\n",
    "            else:\n",
    "                break \n",
    "    return news_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以上提取程序还未解决以下特殊情况:\n",
    "- line1：\"###########言论########\"\n",
    "- line2：某某说，##############\n",
    "\n",
    "在这种情况中，line1也是某某说的话，该程序只提取到了line2后面的话"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 测试提取效果，用以改进提取算法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import re\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 328 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "relatedwords_list = get_relatedwords()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#获取测试新闻\n",
    "news_path = r'E:/MYGIT/DataSources/THUCNews/news_origin/社会新闻_all.txt'\n",
    "news_list = []\n",
    "with open(news_path, encoding='utf-8') as f:\n",
    "    for i in range(10000):\n",
    "        line_str = f.readline()\n",
    "        if line_str == '': break\n",
    "        if line_str.startswith('视频') or line_str.startswith('调查') or len(line_str)>1500: continue\n",
    "        news_list.append(line_str.strip('\\n'))\n",
    "#news_list[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "':' in relatedwords_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'：' in relatedwords_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import gc\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Design Software\\Anaconda\\envs\\py36\\lib\\site-packages\\smart_open\\smart_open_lib.py:398: UserWarning: This function is deprecated, use smart_open.open instead. See the migration notes for details: https://github.com/RaRe-Technologies/smart_open/blob/master/README.rst#migrating-to-the-new-open-function\n",
      "  'See the migration notes for details: %s' % _MIGRATION_NOTES_URL\n"
     ]
    }
   ],
   "source": [
    "model_list = load_all_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'test' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-4e1243bd22c6>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtest\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'test' is not defined"
     ]
    }
   ],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "release_all_model(model_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = random.choice(news_list)\n",
    "test = test.replace('\\u3000','')\n",
    "test = test.replace('\\\\n','')\n",
    "#test += sen\n",
    "sentence_list = cut_sentence(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "sen = '''IG Markets高级分析师DanCook说，“我最大的忧虑是如果消费者失业或没有钱消费，无论消费者如何乐观都变得不重要'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n",
      "Loading model from cache C:\\Users\\Oliver\\AppData\\Local\\Temp\\jieba.cache\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "front\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading model cost 0.936 seconds.\n",
      "Prefix dict has been built succesfully.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "defaultdict(list, {0: ['其家人', '介绍', '小涛的爷爷听说用纯碱水洗酒坛很管用']})"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_opinion_of_someone(sen[1],relatedwords_list,model_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第1句: 地震生死恋人将在北京台春晚完婚本报讯（记者 龙露）今天上午，北京电视台春晚总导演齐建彤宣布，从四川大地震中走出来的一对新人贺晨曦、郑广明将在春节联欢晚会上举行他们的婚礼。\n",
      "第2句: 上午，海淀区新贵大厦二层大宅门餐厅内红灯高挂、北侧的小舞台上布满了鲜花，一对由数百朵红玫瑰组成的两颗“心形”花环紧紧重叠在一起。\n",
      "第3句: 11时，在《童话》悠扬的音乐声中，一对新人贺晨曦、郑广明踏着红地毯穿过花门走上舞台，举行了订婚仪式，新娘贺晨曦身穿蓝色晚礼服，脸上洋溢着幸福的笑容。\n",
      "第4句: 在场的志愿者对新人表达了真情的祝福，餐厅的220名服务员每人捐出了一元钱表达了220个对新人的祝福。\n",
      "第5句: 据介绍，准新郎郑广明来自东北，到四川打工时认识了四川姑娘贺晨曦。\n",
      "第6句: 在四川大地震时，贺晨曦被压在废墟下104个小时。\n",
      "第7句: 当她被救出后，一直昏迷不醒，见此，郑广明不断对她呼唤：你快醒来吧，醒来，我们马上结婚。\n",
      "第8句: 在郑广明爱的呼唤下，贺晨曦终于脱离了危险。\n",
      "第9句: 大地震后，家没了，工作也没了，两人只好挤在一间几平方米的小屋内，仅靠郑广明打工赚到的一点钱维持生计，结婚却成了两人暂时无法完成的一个“梦”。\n",
      "第10句: 北京电视台《真情耀中华》栏目的工作人员得知这个情况后，号召志愿者及所有北京市民共同帮助贺晨曦、郑广明完成这个婚礼。\n",
      "第11句: 12月10日，志愿者从北京出发了。\n",
      "第12句: 15日，两人被接到了北京，北京的志愿者不但为两人定好下榻的酒店，还帮他们定好了订婚的餐厅。\n",
      "第13句: 更多的北京市民打来电话，愿意为两人提供婚车、礼服。\n",
      "第14句: 北京电视台春节联欢晚会总导演齐建彤介绍，贺晨曦、郑广明的正式婚礼要在大年三十的春晚联欢会上举办，我们要为这对新人举办一场盛大的婚礼。\n",
      "第15句: 此外，齐建彤还透露，《真情耀中华》栏目的明星志愿者——电影演员刘烨通过栏目组转来了为新人祝福的红包。\n",
      "第16句: 孙妍 摄\n"
     ]
    }
   ],
   "source": [
    "for _a, i in enumerate(sentence_list):\n",
    "    print('第{}句: {}'.format(_a+1, i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sentence_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#该模块是自己编写的，为了方便观察依存关系树\n",
    "from plottree import plottree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "sen = ['IG Markets高级分析师DanCook说，“我最大的忧虑是如果消费者失业或没有钱消费，无论消费者如何乐观都变得不重要',\n",
    "'''据其家人介绍，小涛的爷爷听说用纯碱水洗酒坛很管用''',\n",
    "'''李某某称，其销售的生羊合格。''',\n",
    "'''单霁翔再次重申：“中国政府高度重视和关心流失海外中国文物的问题''',\n",
    "'''单霁翔说，中国文物流失时间跨度较大''',\n",
    "      '中共中央总书记习近平表示，要加强基础建设',\n",
    "      '据合肥一些玩家透露，目前，我省淮南、淮北一带的一些煤老板也投身“石海”。他们动辄花上百万、千万从一些个人玩家手上收集玉器',\n",
    "      '虚幻引擎3动作游戏《黑光》新作公布曾经开发过多款大受好评电脑军事游戏的美国Zombie Studios公司，日前宣布与福克斯电影合作']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "#word_list = cut_word(sentence_list[0], model_list[0])\n",
    "word_list = cut_word(sen[-1], model_list[0])\n",
    "pos_list = pos_label(word_list, model_list[1])\n",
    "ner_list = ner_label(word_list,pos_list,model_list[2])\n",
    "den_parsing_list = dependency_parsing(word_list,pos_list,model_list[3])\n",
    "dp_list = [str(arc.head) + ':'+ arc.relation for arc in den_parsing_list]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\t|2\t|3\t|4\t|5\t|6\t|7\t|8\t|9\t|10\t|11\t|12\t|13\t|14\t|\n",
      "虚幻引擎\t|3\t|动作\t|游戏\t|《\t|黑光\t|》\t|新作\t|公布\t|曾经\t|开发\t|过\t|多\t|款\t|\n",
      "O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t|O\t| \n",
      "\n",
      "15\t|16\t|17\t|18\t|19\t|20\t|21\t|22\t|23\t\t|24\t\t|25\t|26\t|27\t|28\t|\n",
      "大\t|受\t|好评\t|电脑\t|军事\t|游戏\t|的\t|美国\t|Zombie\t|Studios\t|公司\t|，\t|日前\t|宣布\t|\n",
      "O\t|O\t|O\t|O\t|O\t|O\t|O\t|B-Ni\t|I-Ni\t\t|I-Ni\t\t|E-Ni\t|O\t|O\t|O\t| \n",
      "\n",
      "29\t|30\t|31\t|32\t|\n",
      "与\t|福克斯\t|电影\t|合作\t|\n",
      "O\t|S-Nh\t|O\t|O\t| \n",
      "\n"
     ]
    }
   ],
   "source": [
    "pretty_print(word_list, ner_list)\n",
    "#pretty_print(word_list, pos_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_name(word_list, den_parsing_list, ner_list, pos_list, 26)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "relation_dict = search_find_dict([find_head(den_parsing_list)],den_parsing_list, word_list)\n",
    "start = word_list[find_head(den_parsing_list)]\n",
    "plottree.createPlot(start, relation_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 确定言论结束"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sentence Embedding-基础词向量的句子向量化处理"
   ]
  },
  {
   "attachments": {
    "%E5%9B%BE%E7%89%87.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![%E5%9B%BE%E7%89%87.png](attachment:%E5%9B%BE%E7%89%87.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- line2：计算每条句子的向量，以列存储 原文是 compute the weighted average of the word vector\n",
    "- line6：原文是 remove the projections of the average vectors on their first singular verctor(common component removal),至于为什么line6这样计算会是common component removal，还没弄明白，有空再深究\n",
    "- 最后得到的矩阵是M×N的 M为词向量维度，N为句子个数，可以看出每个句子向量都是以列保存的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "D:\\Design Software\\Anaconda\\envs\\py36\\lib\\site-packages\\smart_open\\smart_open_lib.py:398: UserWarning: This function is deprecated, use smart_open.open instead. See the migration notes for details: https://github.com/RaRe-Technologies/smart_open/blob/master/README.rst#migrating-to-the-new-open-function\n",
      "  'See the migration notes for details: %s' % _MIGRATION_NOTES_URL\n"
     ]
    }
   ],
   "source": [
    "fname = r\"E:/MYGIT/model/wiki_stopwords/wiki_word2vec.kv\"\n",
    "#model_wv.save(fname)\n",
    "model_wv = KeyedVectors.load(fname, mmap='r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "code_folding": [
     4
    ]
   },
   "outputs": [],
   "source": [
    "from gensim.models import KeyedVectors\n",
    "import logging\n",
    "\n",
    "#该函数对应的是上诉图片中伪代码的实现过程\n",
    "def get_sentences_vec(model_wv, sent_list, word_frequence):\n",
    "    # 句子向量化处理\n",
    "    a = 0.001\n",
    "    row = model_wv.vector_size\n",
    "    col = len(sent_list)\n",
    "    sent_mat = np.zeros((row, col))\n",
    "    for i, sent in enumerate(sent_list):\n",
    "        length = len(sent)\n",
    "        sent_vec = np.zeros(row)\n",
    "        for word in sent:\n",
    "            pw = word_frequence[word]\n",
    "            w = a / (a + pw)\n",
    "            try:\n",
    "                vec = np.array(model_wv[word])\n",
    "                sent_vec += w * vec\n",
    "            except:\n",
    "                pass\n",
    "        sent_mat[:, i] += sent_vec\n",
    "        sent_mat[:, i] /= length\n",
    "\n",
    "    # PCA处理\n",
    "    sent_mat = np.mat(sent_mat)\n",
    "    u, s, vh = np.linalg.svd(sent_mat)\n",
    "    sent_mat = sent_mat - u * u.T * sent_mat\n",
    "    return sent_mat\n",
    "\n",
    "def get_word_frequence(words):\n",
    "    #这里不做停用次处理，直接在计算句子向量时候，如果找不到该词，直接跳过\n",
    "    word_list = []\n",
    "    for word in words:\n",
    "        word_list += word\n",
    "    word_frequence = Counter(word_list)\n",
    "    return word_frequence\n",
    "\n",
    "# 计算余弦相似度\n",
    "def cos_similarity(v1, v2):\n",
    "    #输入向量维度不一致\n",
    "    if len(v1) != len(v2):\n",
    "        return 0\n",
    "    return np.vdot(v1,v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))\n",
    "\n",
    "# 返回句子向量矩阵中各列向量与第一列向量的相似度\n",
    "def calcu_similarity(sent_mat):\n",
    "    #采用点积的方法计算\n",
    "    first = np.array(sent_mat[:, 0]).flatten()\n",
    "    col = sent_mat.shape[1]\n",
    "    sims = []\n",
    "    for i in range(1, col):\n",
    "        vec = np.array(sent_mat[:, i]).flatten()\n",
    "        sims.append(cos_similarity(first, vec))\n",
    "    return sims\n",
    "\n",
    "#获取相似度结果\n",
    "def get_similarity_result(word_list_all, model_wv):\n",
    "    word_frequence = get_word_frequence(word_list_all)\n",
    "    sent_mat = get_sentences_vec(model_wv, word_list_all,word_frequence)\n",
    "    sim = calcu_similarity(sent_mat)\n",
    "    return sim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 使用Flask等web框架展示项目成果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "273.2px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
